package org.developer.dynamic.infra.util;

import com.zaxxer.hikari.HikariDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
import org.springframework.boot.context.properties.source.ConfigurationPropertyNameAliases;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.MapConfigurationPropertySource;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.StringUtils;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
  * 动态数据源注册
  * 实现 ImportBeanDefinitionRegistrar 实现数据源注册
  * 实现 EnvironmentAware 用于读取application.yml配置
  *
  * @author yisheng.mikelv@foxmail.com 2020/3/5 11:06
  */
public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);

    /**
     * 配置上下文，即配置文件的获取工具
     */
    private Environment env;

    /**
     * 别名
     */
    private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();

    /**
     * 由于部分数据源配置不同，所以在此处添加别名，避免切换数据源出现某些参数无法注入的情况
     */
    static {
        aliases.addAliases("url", new String[]{"jdbc-url"});
        aliases.addAliases("username", new String[]{"user"});
    }

    /**
     * 存储注册的数据源
     */
    private Map<String, DataSource> customDataSources = new HashMap<String,DataSource>();

    /**
     * 参数绑定工具
     */
    private Binder binder;

    /**
     * ImportBeanDefinitionRegister 接口的实现方法，通过该方法可以按照自己的方式注册 bean
     * @param annotationMetadata
     * @param beanDefinitionRegistry Bean 注册中心
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        //获取所有数据源配置
        Map config,defaultDataSourceProperties;
        //将数据库配置映射成为 key-value 的格式存储在 Map 中
        defaultDataSourceProperties = binder.bind("spring.datasource.master",Map.class).get();
        //从 application.yml 获取数据源类型
        String typeStr = env.getProperty("spring.datasource.master.type");
        Class<? extends DataSource> clazz = getDataSourceType(typeStr);
        //绑定默认数据源参数，也就是主数据源
        DataSource consumerDatasource,defaultDatasource = bind(clazz,defaultDataSourceProperties);
        DynamicDataSourceContextHolder.dataSourceIds.add("master");
        logger.info("注册默认数据源成功");
        //获取其它数据源配置
        //Bindable.listof(Map.class) -> 源码：ResolvableType.forClassWithGenerics(List.class, new Class[]{elementType})
        List<Map> configs = binder.bind("spring.datasource.cluster",Bindable.listOf(Map.class)).get();
        //遍历其它数据源的配置
        for(int i = 0;i<configs.size();++i){
            //获取数据源配置，config(Map)
            config = configs.get(i);
            clazz = getDataSourceType((String) config.get("type"));
            defaultDataSourceProperties = config;
            // 绑定参数,数据源类型和数据库配置参数
            consumerDatasource = bind(clazz, defaultDataSourceProperties);
            // 获取数据源的key，以便通过该key可以定位到数据源
            String key = config.get("key").toString();
            //customeDataSources 为 HashMap<String,DataSourceKey>
            customDataSources.put(key, consumerDatasource);
            // 数据源上下文，用于管理数据源与记录已经注册的数据源key
            DynamicDataSourceContextHolder.dataSourceIds.add(key);
            logger.info("注册数据源{}成功", key);

        }
        // bean定义类
        GenericBeanDefinition define = new GenericBeanDefinition();
        // 设置bean的类型，此处DynamicRoutingDataSource是继承AbstractRoutingDataSource的实现类
        define.setBeanClass(DynamicRoutingDataSource.class);
        // 由于该 bean 的类对象是 DynamicRoutingDataSource，需要设置其两个属性 defaultTargetDataSource 和 targetDataSources
        //所以获取到设置属性的对象
        MutablePropertyValues mpv = define.getPropertyValues();
        // 添加默认数据源，避免key不存在的情况没有数据源可用
        //查看源码可知 AbstractRoutingDataSource 中有两个关键属性 defaultTargetDataSource 和 targetDataSources
        mpv.add("defaultTargetDataSource", defaultDatasource);
        // 添加其他数据源
        mpv.add("targetDataSources", customDataSources);
        // 将该bean注册为datasource，不使用springboot自动生成的datasource
        beanDefinitionRegistry.registerBeanDefinition("datasource", define);
        logger.info("注册数据源成功，一共注册{}个数据源", customDataSources.keySet().size() + 1);
    }

    /**
     * 绑定参数，以下三个方法都是参考DataSourceBuilder的bind方法实现的，目的是尽量保证我们自己添加的数据源构造过程与springboot保持一致
     * @param result
     * @param properties
     */
    // TODO: 2020/3/5 研究下 DataSourceBuilder 源码
    private void bind(DataSource result,Map properties){
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        //将参数绑定到对象
        binder.bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(result));
    }

    private <T extends DataSource> T bind(Class<T> clazz, Map properties) {
        //将 Map 转换为 LinkedHashMap
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 通过类型绑定参数并获得实例对象
        return binder.bind(ConfigurationPropertyName.EMPTY, Bindable.of(clazz)).get();
    }

    /**
     *
     * @param clazz 类对象
     * @param sourcePath 参数路径，对应配置文件中的值，如: spring.datasource
     * @param <T>
     * @return
     */
    private <T extends DataSource> T bind(Class<T> clazz,String sourcePath){
        Map properties = binder.bind(sourcePath,Map.class).get();
        return bind(clazz,properties);
    }

    /**
     * 通过字符串获取数据源 class 对象
     * @param typeStr
     * @return
     */
    private Class<? extends DataSource> getDataSourceType(String typeStr) {
        Class<? extends DataSource> type;
        try{
            //hasLength --> 该string对象不为空且长度大于0
            if(StringUtils.hasLength(typeStr)){
                //字符串不为空则通过反射获取class对象
                type = (Class<? extends DataSource>) Class.forName(typeStr);
            }else{
                //默认为 hikariCP 数据源
                type = HikariDataSource.class;
            }

            return type;
        } catch (ClassNotFoundException e) {
            //无法通过反射获取class对象的情况则抛出异常，该情况一般是写错了，所以此次抛出一个runtimeexception
            throw new IllegalArgumentException("can not resolve class with type：" + typeStr);
        }
    }

    /**
     * EnvironmentAware 接口的实现方法，通过 aware 的方式注入，此处是 environment 对象
     * @param environment
     */
    @Override
    public void setEnvironment(Environment environment) {
        logger.info("开始注册数据源");
        this.env = environment;
        //绑定配置器
        binder = Binder.get(env);
    }
}
